// test_interaction_apis.js - 测试用户互动相关接口
const axios = require('axios');
const fs = require('fs');

// 测试配置
const BASE_URL = 'http://localhost:3000/api/interactions';
const AUTH_BASE_URL = 'http://localhost:3000/api/auth';
const TEST_DATA = {
  VALID_USERNAME: 'user', // 使用用户提供的用户名
  VALID_PASSWORD: '123456', // 使用用户提供的密码
  TEST_VIDEO_ID: 1 // 请确保这个视频ID存在
};

// 测试结果记录
const testResults = {
  total: 0,
  passed: 0,
  failed: 0,
  tests: []
};

// 记录测试结果
function recordTestResult(testName, passed, message = '') {
  testResults.total++;
  if (passed) {
    testResults.passed++;
  } else {
    testResults.failed++;
  }
  
  testResults.tests.push({
    name: testName,
    passed,
    message
  });
  
  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${testName}`);
  if (!passed && message) {
    console.log(`  Error: ${message}`);
  }
}

// 保存测试结果到文件
function saveTestResults() {
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const filename = `interaction_test_results_${timestamp}.json`;
  
  fs.writeFileSync(filename, JSON.stringify(testResults, null, 2));
  console.log(`\n测试结果已保存到: ${filename}`);
  console.log(`总测试数: ${testResults.total}`);
  console.log(`通过数: ${testResults.passed}`);
  console.log(`失败数: ${testResults.failed}`);
}

// 用户登录获取token
async function loginUser() {
  try {
    const response = await axios.post(`${AUTH_BASE_URL}/login`, {
      username: TEST_DATA.VALID_USERNAME,
      password: TEST_DATA.VALID_PASSWORD
    });
    
    if (response.data.code === 200 && response.data.data && response.data.data.token) {
      return response.data.data.token;
    } else {
      recordTestResult('用户登录', false, response.data.message || '登录失败');
      return null;
    }
  } catch (error) {
    recordTestResult('用户登录', false, error.message);
    return null;
  }
}

// 测试点赞视频接口
async function testLikeVideo(token) {
  try {
    const response = await axios.post(`${BASE_URL}/like`, 
      { videoId: TEST_DATA.TEST_VIDEO_ID },
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200 || response.data.code === 400) {
      // 400可能是因为已经点赞过，这也是可接受的
      recordTestResult('点赞视频', true);
      return true;
    } else {
      recordTestResult('点赞视频', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('点赞视频', false, error.message);
    return false;
  }
}

// 测试取消点赞接口
async function testUnlikeVideo(token) {
  try {
    const response = await axios.post(`${BASE_URL}/unlike`, 
      { videoId: TEST_DATA.TEST_VIDEO_ID },
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200 || response.data.code === 400) {
      // 400可能是因为已经取消点赞过，这也是可接受的
      recordTestResult('取消点赞', true);
      return true;
    } else {
      recordTestResult('取消点赞', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('取消点赞', false, error.message);
    return false;
  }
}

// 测试检查点赞状态接口
async function testCheckLikeStatus(token) {
  try {
    const response = await axios.get(
      `${BASE_URL}/like/status?videoId=${TEST_DATA.TEST_VIDEO_ID}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200) {
      recordTestResult('检查点赞状态', true);
      return true;
    } else {
      recordTestResult('检查点赞状态', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('检查点赞状态', false, error.message);
    return false;
  }
}

// 测试获取用户点赞视频列表接口
async function testGetUserLikedVideos(token) {
  try {
    const response = await axios.get(
      `${BASE_URL}/like/list?page=1&pageSize=10`,
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200) {
      recordTestResult('获取用户点赞视频列表', true);
      return true;
    } else {
      recordTestResult('获取用户点赞视频列表', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('获取用户点赞视频列表', false, error.message);
    return false;
  }
}

// 测试收藏视频接口
async function testFavoriteVideo(token) {
  try {
    const response = await axios.post(`${BASE_URL}/favorite`, 
      { videoId: TEST_DATA.TEST_VIDEO_ID },
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200 || response.data.code === 400) {
      // 400可能是因为已经收藏过，这也是可接受的
      recordTestResult('收藏视频', true);
      return true;
    } else {
      recordTestResult('收藏视频', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('收藏视频', false, error.message);
    return false;
  }
}

// 测试取消收藏接口
async function testUnfavoriteVideo(token) {
  try {
    const response = await axios.post(`${BASE_URL}/unfavorite`, 
      { videoId: TEST_DATA.TEST_VIDEO_ID },
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200 || response.data.code === 400) {
      // 400可能是因为已经取消收藏过，这也是可接受的
      recordTestResult('取消收藏', true);
      return true;
    } else {
      recordTestResult('取消收藏', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('取消收藏', false, error.message);
    return false;
  }
}

// 测试检查收藏状态接口
async function testCheckFavoriteStatus(token) {
  try {
    const response = await axios.get(
      `${BASE_URL}/favorite/status?videoId=${TEST_DATA.TEST_VIDEO_ID}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200) {
      recordTestResult('检查收藏状态', true);
      return true;
    } else {
      recordTestResult('检查收藏状态', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('检查收藏状态', false, error.message);
    return false;
  }
}

// 测试获取用户收藏视频列表接口
async function testGetUserFavoriteVideos(token) {
  try {
    const response = await axios.get(
      `${BASE_URL}/favorite/list?page=1&pageSize=10`,
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200) {
      recordTestResult('获取用户收藏视频列表', true);
      return true;
    } else {
      recordTestResult('获取用户收藏视频列表', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('获取用户收藏视频列表', false, error.message);
    return false;
  }
}

// 测试获取视频评论列表接口（无需认证）
async function testGetVideoComments() {
  try {
    const response = await axios.get(
      `${BASE_URL}/comments/${TEST_DATA.TEST_VIDEO_ID}?page=1&pageSize=10`
    );
    
    if (response.data.code === 200) {
      recordTestResult('获取视频评论列表（无需认证）', true);
      return true;
    } else {
      recordTestResult('获取视频评论列表（无需认证）', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('获取视频评论列表（无需认证）', false, error.message);
    return false;
  }
}

// 测试创建评论接口
async function testCreateComment(token) {
  try {
    const response = await axios.post(`${BASE_URL}/comments`, 
      {
        videoId: TEST_DATA.TEST_VIDEO_ID,
        content: '这是一条测试评论' + new Date().getTime()
      },
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 201) {
      recordTestResult('创建评论', true);
      return response.data.data.id; // 返回创建的评论ID，用于后续删除测试
    } else {
      recordTestResult('创建评论', false, response.data.message || '未知错误');
      return null;
    }
  } catch (error) {
    recordTestResult('创建评论', false, error.message);
    return null;
  }
}

// 测试删除评论接口
async function testDeleteComment(token, commentId) {
  try {
    const response = await axios.delete(
      `${BASE_URL}/comments/${commentId}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );
    
    if (response.data.code === 200) {
      recordTestResult('删除评论', true);
      return true;
    } else {
      recordTestResult('删除评论', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('删除评论', false, error.message);
    return false;
  }
}

// 测试未认证请求是否会被正确拒绝
async function testUnauthorizedAccess() {
  try {
    // 尝试不带token访问需要认证的接口
    const response = await axios.post(`${BASE_URL}/like`, 
      { videoId: TEST_DATA.TEST_VIDEO_ID },
      { validateStatus: false } // 不抛出异常，获取所有状态码
    );
    
    if (response.status === 401) {
      recordTestResult('未认证请求拒绝测试', true);
      return true;
    } else {
      recordTestResult('未认证请求拒绝测试', false, `期望401状态码，实际得到${response.status}`);
      return false;
    }
  } catch (error) {
    recordTestResult('未认证请求拒绝测试', false, error.message);
    return false;
  }
}

// 测试获取不存在视频的评论列表
async function testGetNonExistentVideoComments() {
  try {
    const nonExistentVideoId = 999999; // 假设这个ID不存在
    const response = await axios.get(
      `${BASE_URL}/comments/${nonExistentVideoId}?page=1&pageSize=10`
    );
    
    // 即使视频不存在，接口也应该返回200，只是评论列表为空
    if (response.data.code === 200) {
      recordTestResult('获取不存在视频的评论列表', true);
      return true;
    } else {
      recordTestResult('获取不存在视频的评论列表', false, response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    recordTestResult('获取不存在视频的评论列表', false, error.message);
    return false;
  }
}

// 测试无效参数的情况
async function testInvalidParameters() {
  try {
    // 测试获取评论列表时传入无效的videoId
    const response = await axios.get(
      `${BASE_URL}/comments/invalid?page=1&pageSize=10`,
      { validateStatus: false }
    );
    
    if (response.status === 400 || response.status === 500) {
      recordTestResult('无效参数测试', true);
      return true;
    } else {
      recordTestResult('无效参数测试', false, `期望400或500状态码，实际得到${response.status}`);
      return false;
    }
  } catch (error) {
    recordTestResult('无效参数测试', true); // 发生异常也是一种合理的响应
    return true;
  }
}

// 主测试函数
async function runTests() {
  console.log('开始测试用户互动接口...');
  
  try {
    console.log('\n===== 测试无需认证的接口 =====');
    // 测试不需要认证的接口
    await testGetVideoComments();
    await testGetNonExistentVideoComments();
    await testInvalidParameters();
    
    console.log('\n===== 测试认证机制 =====');
    // 测试未认证请求是否会被正确拒绝
    await testUnauthorizedAccess();
    
    console.log('\n===== 尝试测试需要认证的接口（需要有效的用户凭证）=====');
    console.log(`注意：当前使用的测试用户凭证是用户名: ${TEST_DATA.VALID_USERNAME}`);
    console.log('如果登录失败，请检查测试用户是否存在并且密码正确');
    
    // 获取认证token
    const token = await loginUser();
    if (token) {
      console.log('登录成功，可以测试需要认证的接口');
      
      console.log('\n===== 测试点赞相关接口 =====');
      // 测试点赞相关接口
      await testLikeVideo(token);
      await testCheckLikeStatus(token);
      await testGetUserLikedVideos(token);
      await testUnlikeVideo(token);
      
      console.log('\n===== 测试收藏相关接口 =====');
      // 测试收藏相关接口
      await testFavoriteVideo(token);
      await testCheckFavoriteStatus(token);
      await testGetUserFavoriteVideos(token);
      await testUnfavoriteVideo(token);
      
      console.log('\n===== 测试评论相关接口（需要认证的部分）=====');
      // 测试评论相关接口
      const commentId = await testCreateComment(token);
      if (commentId) {
        await testDeleteComment(token, commentId);
      }
    } else {
      console.log('登录失败，跳过需要认证的接口测试');
      console.log('提示：请在TEST_DATA对象中设置正确的用户名和密码');
    }
    
  } catch (error) {
    console.error('测试过程中发生错误:', error);
  } finally {
    saveTestResults();
  }
}

// 运行测试
runTests();